1. Field of the Invention
The present invention relates to an operation system (to be abbreviated to as an "OS" hereinafter) for a so-called "Neumann type (stored program)" computer for executing processing according to a program prepared by a user according to his or her problem and, more particularly, to an OS having a migration function for a computer, which allows efficient use of a computer system.
2. Description of the Related Art
A software program of a normal computer, in particular, of a main-frame type computer, is constituted by a user definition program used by a user to designate a processing sequence, and an OS for a system.
The user definition program (so-called a user program) is a program for mainly instructing a sequence of calculations (processing) according to an individual problem to a computer side. It is cumbersome to use computers if specifications of program languages are different from each other depending on the types of computer. Therefore, in recent years, the specifications of program languages have been standardized. For example, high-level languages such as FORTRAN, BASIC, ALGOL, C, PASCAL, COBOL, and the like are widely used.
In contrast to the program languages, since an OS is a system software group unique to each type of computer, it must provide a procedure system for compiling, linking and executing user programs (i.e. user definition programs) coded in a high-level language, and a multi-process environment (e.g. real-time multi-task processing system) in a normal computer. Therefore, the OS has a control system for performing management and scheduling of individual jobs, and management and monitoring of resources, and providing a user environment (e.g., utilities, etc.), and performs all the tasks necessary for operating the computer.
OSs of computers are not basically standardized at the present time, and are different in each type of computer. However, a tendency for standardizing OSs has been shown. In general-purpose computers, UNIX is substantially regarded as a standard OS. In small computers, MS-DOS is similarly regarded as a standard OS. In very recent years, MACH as a development type of the above-mentioned UNIX, OS/2 as a development type of the above-mentioned MS-DOS, and the like have been proposed, and computers packaging these OSs are commercially available.
Important tasks to be executed by an OS include "management" and "monitoring" of resources. In general, the "resources" represent hardware (mainly, memory units, e.g., a main memory area, a semiconductor memory device, a magnetic memory device, etc. as external memory devices) which can be used by a job, and system software (e.g., a compiler for compiling a program coded in a high-level language, a linker, a loader, various utilities provided by a system, general-purpose software programs, and the like).
How much these resources are used depends on the content of a user program to be executed. Some computers give resources requested by a user program as much as possible without limitations. However, in a computer such as a general-purpose large-scale computer which executes processing of jobs of a large number of users in a "multi-task system", predetermined default values (i.e., predetermined system values) are determined beforehand for computer resources which are given independently of programs designated by users in consideration of operating efficiency and resource efficiency of the overall system. Thus, wasteful calculations and continuous execution of an infinite arithmetic loop (so-called a permanent loop) which can never be logically or practically ended, particularly caused by errors in a user definition program, can be avoided. However, some jobs cannot be executed by the above-mentioned method. In this case, a user must analyze a cause of abnormal termination, must properly change upper limit values of useable resources (e.g., a memory capacity, time), and thereafter, must re-execute the job from the beginning.
In a large-scale general-purpose computer, limitations of resources used by a job can be desirably designated in a specification (e.g. syntax) of a "job control language (to be abbreviated to as a "JCL" hereinafter)". For example, the resources include the upper limit value of the capacity of a main memory (e.g., a user memory size, etc.) which must be used by a job, the upper limit value of the CPU occupation time, and the like. However, it is very difficult to precisely obtain estimation values of resources necessary for actual processing. For example, in an actual operation, execution of a job is often interrupted during processing since no resources remain, although processing would be ended soon to obtain a processing result. For a small job (which requires short processing time), the upper limit values of useable computer resources can be set again to be larger values, and the job can be re-executed. However, for a large job (which requires long processing time), the above-mentioned re-execution processing considerably wastes CPU time and memory resources. Conventional computers disregard the above-mentioned problems.
During a development process of a large-scale program, test data are prepared. More specifically, test data which are used as actual data to immediately complete calculations, and allow to easily check whether or not the execution result is proper are prepared, thereby checking whether or not a program is normally operated. Therefore, a main memory capacity, a magnetic memory capacity, and the like (i.e., a program size) required by the program can be determined after the test calculations using the above-mentioned test data. On the other hand, in a test case, since processing is immediately completed (due to a small number of data), a predicted calculation (processing) time obtained as a result of the test case cannot be used as a reference time. In a processing method adopted in scientific and technical calculations, calculations are frequently repeated and are terminated only after the calculated value converges to a required precision. However, in such a processing method, it is almost impossible to experimentally estimate a calculation time (i.e. CPU occupation time). In particular, in large-scale calculation processing, a slight underestimation result of the calculation time (i.e. CPU occupation time) often leads to considerable wastes upon execution of actual processing.
It is difficult to estimate not only the "calculation time (i.e. CPU occupation time)" of resources but also the "capacity" of a magnetic memory device. More specifically, in order to permanently store data in most of existing large-scale computers, after a data file is created on an external magnetic memory device, a memory area assigned to this file is utilized. When a user uses this magnetic memory device, he or she must designate a data capacity (e.g. size (MB)) in advance. In general, it is considered that the maximum capacity of a magnetic memory device is smaller than a physical memory space capacity, and is equal to the capacity of a logical memory space. When a user roughly estimates a data amount, he or she can calculate it based on the number of words, the word length, and the like. However, in particular, when the user is a beginner, he or she often fails to correctly estimate the data amount. As a result, even though actual calculation processing is completely ended, in "write processing" executed after the calculation processing is ended, i.e., when data are finally written in a logical file of the magnetic memory device in the magnetic memory device of the set capacity, a series of processing operations may be abnormally terminated since the data cannot be completely written within the available capacity.
In order to prevent such abnormal termination, recent computers are improved to be able to designate a "primary assignment amount (so called, primary quantity)" and an "increase amount (so called, secondary quantity)". The "primary quantity" is an amount required at the beginning of execution, and the "secondary quantity" is an amount increased after the primary quantity is used up. A permanent file capacity can be expanded by a predetermined number of times (e.g., 10 times) according to the increase amount. Even when the above-mentioned method is employed, the resources are sometimes used up, and write processing may often be unsuccessful.
In general, the resources are often used up from a viewpoint of a user. However, in this case, a computer system has not always really used up its resources (i.e., a memory capacity). Meanwhile, the CPU time is almost infinitely present on the computer side. More specifically, the computer still has a margin for a memory capacity. However, the computer has some limitations in consideration of multi-task operations. More specifically, these limitations are set to avoid a phenomenon that if an excessively large resource is assigned to one task, other tasks cannot be operated. However, if this job is abnormally terminated, it must be re-executed after the resource assignment amount is changed, and wasteful calculation processing must be executed again. In consideration of wastes caused by the above re-calculation processing, whether or not the above-mentioned limitations themselves are proper is doubtful in view of efficient utilization of the overall computer, and of improvement of the throughput of the overall computer (in a sense of obtaining a necessary result).
Some recent large-scale computers have job "restart" functions. However, these functions can only basically define post processing when a job is abnormally terminated. In most cases, only an operator of a computer is allowed to operate these functions, and no countermeasure against a case wherein resources are used up is particularly taken in the OS.
In general, to use resources beyond expectations is a miss for a user in a wide sense. The cause of such a miss is often merely an estimation error of the CPU time or memory capacity. Therefore, it is important for a user and a computer to consider such "harmless misses" separately from abnormal terminations.
As described above, in a conventional computer, when a resource amount set in advance by a user runs short, a corresponding job is interrupted during processing, and a result of calculation processing obtained so far is wasted. Thus, if a sufficient set amount of a resource is assured in advance, such a problem can be prevented. However, this setting may waste the finite resources. More specifically, in the conventional resource setting system, utilization efficiency of a computer is decreased.